package cn.iocoder.yudao.module.trade.service.ordersafetychecktemplateitem;

import cn.hutool.core.collection.CollectionUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.CheckUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.trade.controller.admin.ordersafetychecktemplate.vo.OrderSafetyCheckTemplateRespVO;
import cn.iocoder.yudao.module.trade.controller.admin.ordersafetychecktemplateitem.vo.OrderSafetyCheckTemplateItemPageReqVO;
import cn.iocoder.yudao.module.trade.controller.admin.ordersafetychecktemplateitem.vo.OrderSafetyCheckTemplateItemRespVO;
import cn.iocoder.yudao.module.trade.controller.admin.ordersafetychecktemplateitem.vo.OrderSafetyCheckTemplateItemSaveReqVO;
import cn.iocoder.yudao.module.trade.controller.admin.ordersafetycheckterm.vo.OrderSafetyCheckTermSaveReqVO;
import cn.iocoder.yudao.module.trade.dal.dataobject.ordersafetychecktemplateitem.OrderSafetyCheckTemplateItemDO;
import cn.iocoder.yudao.module.trade.dal.dataobject.ordersafetycheckterm.OrderSafetyCheckTermDO;
import cn.iocoder.yudao.module.trade.dal.mysql.ordersafetychecktemplateitem.OrderSafetyCheckTemplateItemMapper;
import cn.iocoder.yudao.module.trade.dal.mysql.ordersafetycheckterm.OrderSafetyCheckTermMapper;
import cn.iocoder.yudao.module.trade.service.ordersafetycheckterm.OrderSafetyCheckTermService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import javax.annotation.Resource;

import java.util.List;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.trade.enums.ErrorCodeConstants.ORDER_SAFETY_CHECK_TEMPLATE_ITEM_NOT_EXISTS;

/**
 * 安全检查明细 Service 实现类
 *
 * @author 芋道源码
 */
@Service
@Validated
public class OrderSafetyCheckTemplateItemServiceImpl implements OrderSafetyCheckTemplateItemService {

    @Resource
    private OrderSafetyCheckTemplateItemMapper orderSafetyCheckTemplateItemMapper;

    @Resource
    private OrderSafetyCheckTermService orderSafetyCheckTermService;

    @Resource
    private OrderSafetyCheckTermService orderSafetyCheckService;

    @Resource
    private OrderSafetyCheckTermMapper orderSafetyCheckTermMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createOrderSafetyCheckTemplateItem(List<OrderSafetyCheckTemplateItemSaveReqVO> createReqVO) {
        if (CollectionUtil.isEmpty(createReqVO)) {
            return null;
        }

        List<OrderSafetyCheckTemplateItemDO> orderItems = BeanUtils.toBean(createReqVO, OrderSafetyCheckTemplateItemDO.class);

        LambdaQueryWrapperX<OrderSafetyCheckTemplateItemDO> items = new LambdaQueryWrapperX<>();
        items.eq(OrderSafetyCheckTemplateItemDO::getTemplateId, orderItems.get(0).getTemplateId())
                .eq(OrderSafetyCheckTemplateItemDO ::getStatus , 0 );
        List<OrderSafetyCheckTemplateItemDO> itemDOS = orderSafetyCheckTemplateItemMapper.selectList(items);

        List<Long> collect1 = orderItems.stream().map(OrderSafetyCheckTemplateItemDO::getId).collect(Collectors.toList());

        List<Long> collect2 = itemDOS.stream().map(OrderSafetyCheckTemplateItemDO::getId).collect(Collectors.toList());

        List<Long> collect = collect2.stream().filter(x -> !collect1.contains(x)).collect(Collectors.toList());

        if (CollectionUtil.isNotEmpty(collect)) {
            collect.forEach(x -> {
                orderSafetyCheckTemplateItemMapper.updateById(new OrderSafetyCheckTemplateItemDO().setId(x).setStatus(1));
            });
        }
        // 批量插入安检项
        orderItems.forEach(x -> {

            if (!CheckUtils.isEmpty(x.getId())){
                OrderSafetyCheckTemplateItemDO orderSafetyCheckTemplateItemDO = orderSafetyCheckTemplateItemMapper.selectById(x.getId());
                // 如果比较相等则比较安检明细
                if (StringUtils.isNotEmpty(x.getTitle()) && orderSafetyCheckTemplateItemDO.getTitle().equals(x.getTitle())) {
                    x.getTermSaveReqVOList().forEach(y -> {
                        y.setItemId(x.getId());
                    });

                    orderSafetyCheckTermService.compareCheckItem(x.getTermSaveReqVOList());
                    return;
                }

                // 如果比较不相等 则需要新增一条安检项及安检项所有明细 并将此id的安检项和明显状态status修改为1停用
                if (StringUtils.isNotEmpty(x.getTitle()) && !orderSafetyCheckTemplateItemDO.getTitle().equals(x.getTitle())) {
                    orderSafetyCheckTemplateItemMapper.updateById(new OrderSafetyCheckTemplateItemDO().setId(x.getId()).setStatus(1));
                    x.setId(null);
                    orderSafetyCheckTemplateItemMapper.insert(x);
                    x.getTermSaveReqVOList().forEach(id -> {
                        id.setItemId(x.getId());
                    });
                    orderSafetyCheckTermService.compareCheckItem(x.getTermSaveReqVOList());
                    return;

                }
            }
            if (CheckUtils.isEmpty(x.getId())){
                // 新增安检项和安检明细
                saveAll(BeanUtils.toBean(x, OrderSafetyCheckTemplateItemDO.class));
            }

        });

        // 返回
        return orderItems.stream().findFirst().get().getId();
    }

    // 新增安检项和安检明细
    private void saveAll(OrderSafetyCheckTemplateItemDO templateItemDO) {
        orderSafetyCheckTemplateItemMapper.insert(templateItemDO);

        List<OrderSafetyCheckTermSaveReqVO> reqVOList = templateItemDO.getTermSaveReqVOList();
        //批量插入安检项详情
        if (CollectionUtil.isNotEmpty(reqVOList)) {
            reqVOList.forEach(xy -> {
                xy.setItemId(templateItemDO.getId());
            });
            orderSafetyCheckTermService.insertBathList(reqVOList);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateOrderSafetyCheckTemplateItem(List<OrderSafetyCheckTemplateRespVO> updateReqVO) {
        // 校验存在
        // 更新
        List<OrderSafetyCheckTemplateItemDO> updateObj = BeanUtils.toBean(updateReqVO, OrderSafetyCheckTemplateItemDO.class);
        List<Long> collect = updateObj.stream().map(OrderSafetyCheckTemplateItemDO::getId).collect(Collectors.toList());

        LambdaQueryWrapperX<OrderSafetyCheckTemplateItemDO> wrapperX = new LambdaQueryWrapperX<>();
        wrapperX.eqIfPresent(OrderSafetyCheckTemplateItemDO::getTemplateId, updateReqVO.stream().findFirst().get().getId());

        List<Long> collect1 = orderSafetyCheckTemplateItemMapper.selectList(wrapperX).stream().map(OrderSafetyCheckTemplateItemDO::getId).collect(Collectors.toList());

        List<Long> collect2 = collect1.stream().filter(x -> !collect.contains(x)).collect(Collectors.toList());

        orderSafetyCheckTemplateItemMapper.deleteBatchIds(collect2);
        // 删除安检项标题对应的安检明细
        orderSafetyCheckTermService.deleteBatchItemIds(collect2);

        updateReqVO.forEach(x -> {
            // 批量更新安检项详情
            if (CollectionUtil.isNotEmpty(x.getTermSaveReqVOList())) {
                orderSafetyCheckTermService.updateBathList(x.getTermSaveReqVOList());
            }
        });

    }


    @Override
    public void deleteOrderSafetyCheckTemplateItem(Long id) {
        // 校验存在
        validateOrderSafetyCheckTemplateItemExists(id);
        // 删除
        orderSafetyCheckTemplateItemMapper.deleteById(id);
    }

    private void validateOrderSafetyCheckTemplateItemExists(Long id) {
        if (orderSafetyCheckTemplateItemMapper.selectById(id) == null) {
            throw exception(ORDER_SAFETY_CHECK_TEMPLATE_ITEM_NOT_EXISTS);
        }
    }

    @Override
    public List<OrderSafetyCheckTemplateItemRespVO> getOrderSafetyCheckTemplateItem(Long id) {
        LambdaQueryWrapperX<OrderSafetyCheckTemplateItemDO> queryWrapper = new LambdaQueryWrapperX<>();
        queryWrapper.eq(OrderSafetyCheckTemplateItemDO ::getTemplateId, id )
                .eq(OrderSafetyCheckTemplateItemDO :: getStatus, 0 )
                .orderByAsc(OrderSafetyCheckTemplateItemDO ::getSort );

        List<OrderSafetyCheckTemplateItemDO> itemDOList = orderSafetyCheckTemplateItemMapper.selectList(queryWrapper);
        List<OrderSafetyCheckTemplateItemRespVO> respVOList = BeanUtils.toBean(itemDOList, OrderSafetyCheckTemplateItemRespVO.class);
        respVOList.forEach(x -> {
            // 查询安检标题对应的安检项
            List<OrderSafetyCheckTermSaveReqVO> termList = orderSafetyCheckService.getOrderSafetyCheckTermList(x.getId());
            if (CollectionUtil.isNotEmpty(termList)){
                x.setTermSaveReqVOList(termList);
            }
        });
        return respVOList;
    }

    @Override
    public PageResult<OrderSafetyCheckTemplateItemDO> getOrderSafetyCheckTemplateItemPage(OrderSafetyCheckTemplateItemPageReqVO pageReqVO) {
        return orderSafetyCheckTemplateItemMapper.selectPage(pageReqVO);
    }

    @Override
    public List<OrderSafetyCheckTemplateItemDO> getOrderSafetyCheckTemplateItemByTemplateId(Long templateId) {
        return orderSafetyCheckTemplateItemMapper.selectList(OrderSafetyCheckTemplateItemDO::getTemplateId,templateId);
    }

}